package com.lanhai.zhonglai;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;


@Configuration
public class ThreadConfig {
	 @Bean
     public Executor agvExecutor() {
          ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
          executor.setCorePoolSize(150); //核心线程池数
          executor.setMaxPoolSize(600); //最大线程池数
          executor.setQueueCapacity(1200); //任务队列的容量
          executor.setKeepAliveSeconds(1);  //非核心线程的存活时间

          /**
           * 拒绝处理策略
           * CallerRunsPolicy()：交由调用方线程运行，比如 main 线程。
           * AbortPolicy()：直接抛出异常。
           * DiscardPolicy()：直接丢弃。
           * DiscardOldestPolicy()：丢弃队列中最老的任务。
           */
          //executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
          executor.initialize();
          return executor;
     }



     /**
      *   默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，
      *	当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
      *  当队列满了，就继续创建线程，当线程数量大于等于maxPoolSize后，开始使用拒绝策略拒绝
      */

     /**
      * 核心线程数（默认线程数）
      */
     private static final int corePoolSize = 100;
     /**
      * 最大线程数
      */
     private static final int maxPoolSize = 200;
     /**
      * 允许线程空闲时间（单位：默认为秒）
      */
     private static final int keepAliveTime = 10;

     /**
      * 队列的大小
      */
     private static final  int queueSize = 10000;

     /**
      * msg线程池
      * @return
      */
     @Bean("msgExecutor")
     public ThreadPoolExecutor msgExecutor() {
          ThreadPoolExecutor executor = new ThreadPoolExecutor(
                  corePoolSize,
                  maxPoolSize,
                  keepAliveTime,
                  TimeUnit.MICROSECONDS,
                  new ArrayBlockingQueue<Runnable>(queueSize),
                  new ThreadPoolExecutor.CallerRunsPolicy());
          return executor;
     }




}
